/**
 * Tauri API调用及后备实现
 */

// 定义invoke函数类型
export type InvokeFunction = (cmd: string, args?: any) => Promise<any>;

// 初始状态下的invoke变量
let invoke: InvokeFunction;

// 标记API是否已初始化
let apiInitialized = false;

// 定义全局接口
interface ElectronAPI {
    invoke: (channel: string, data: any) => Promise<any>;
    onStreamData: (callback: (event: any, chunk: string) => void) => void;
    onStreamError: (callback: (event: any, error: string) => void) => void;
}

// 扩展Window接口
declare global {
    interface Window {
        electron?: ElectronAPI;
    }
}

/**
 * 初始化API
 * 尝试导入Tauri API，如果不可用则使用自定义HTTP实现
 */
export const initApi = async (): Promise<void> => {
    if (typeof window !== 'undefined' && 'Tauri' in window) {
        try {
            // 使用动态导入，避免类型问题
            const tauri = await import('@tauri-apps/api');
            // 在Tauri 2.x中，invoke可能位于不同位置
            // @ts-ignore - 忽略类型检查
            invoke = tauri.invoke || createFallbackInvoke();
            console.log('成功加载Tauri API');
            apiInitialized = true;
            return;
        } catch (error) {
            console.warn('无法加载Tauri API，将使用HTTP请求实现:', error);
        }
    } else {
        console.warn('Tauri环境不可用，使用HTTP请求实现');
    }

    // 提供一个自定义的invoke实现，使用普通HTTP请求
    invoke = createFallbackInvoke();
    apiInitialized = true;
};

/**
 * 确保API初始化完成
 * @returns 是否初始化成功
 */
export const ensureApiInitialized = async (): Promise<boolean> => {
    if (!apiInitialized) {
        await initApi();
    }
    return apiInitialized;
};

/**
 * 创建一个后备的invoke实现
 */
export const createFallbackInvoke = (): InvokeFunction => {
    return async (cmd: string, args?: any): Promise<any> => {
        // 支持的API调用命令列表
        const supportedApiCommands = [
            'call_openai_api',
            'call_ai_api',
            'call_deepseek_api',
            'call_siliconflow_api'
        ];

        // 检查命令是否为支持的API调用命令
        if (supportedApiCommands.includes(cmd)) {
            try {
                // 清理和记录参数
                const { apiKey, model, request_options } = args;

                console.log(`调用API命令: ${cmd}, 参数:`, {
                    apiKeyLength: apiKey?.length || 0,
                    modelName: model || '未直接指定',
                    requestOptions: typeof request_options === 'string' ? 'JSON字符串' : '对象',
                });

                // 检查API密钥
                if (!apiKey) {
                    console.error('API密钥为空或无效');
                    return {
                        success: false,
                        error: '未提供API密钥'
                    };
                }

                // 解析选项
                let options;
                try {
                    options = typeof request_options === 'string' ? JSON.parse(request_options) : request_options;
                    // 确保options包含必要字段
                    if (!options) {
                        throw new Error('Invalid request options');
                    }

                    // 优先使用直接传递的model参数
                    if (model) {
                        options.model = model;
                    }

                    if (!options.model || !options.messages) {
                        throw new Error('Missing required fields');
                    }
                } catch (parseError) {
                    console.error('解析请求选项失败，保留原始参数:', parseError);
                    // 尝试从原始参数中恢复必要字段
                    options = {
                        model: model || 'deepseek-chat', // 优先使用直接传递的model参数
                        messages: [],
                        ...(typeof request_options === 'object' ? request_options : {})
                    };
                }

                // 检查模型和消息
                if (!options.model) {
                    console.error('请求中未指定模型');
                    options.model = 'deepseek-chat';
                }

                if (!options.messages || !Array.isArray(options.messages) || options.messages.length === 0) {
                    console.error('请求中消息为空或无效');
                    return {
                        success: false,
                        error: '无效的消息格式'
                    };
                }

                // 记录请求详情
                console.log('调用API, 请求选项:', {
                    model: options.model,
                    messages: options.messages?.length || 0,
                    temperature: options.temperature,
                    max_tokens: options.max_tokens
                });

                // 确定模型所属的提供商
                const modelLower = options.model.toLowerCase();
                const provider = (() => {
                    if (modelLower.includes('deepseek')) {
                        return 'deepseek';
                    } else if (
                        modelLower.includes('glm') ||
                        modelLower.includes('zhipu') ||
                        modelLower.includes('yi') ||
                        modelLower.includes('qwen') ||
                        modelLower.includes('moonshot') ||
                        modelLower.includes('baichuan')
                    ) {
                        return 'siliconflow';
                    } else {
                        return 'unknown';
                    }
                })();

                // 覆盖provider，优先使用cmd中指定的提供商
                const cmdProvider = cmd.includes('deepseek') ? 'deepseek' :
                    cmd.includes('siliconflow') ? 'siliconflow' :
                        provider;

                console.log(`检测到模型提供商: ${cmdProvider}(来自命令: ${cmd}), 模型: ${options.model}`);

                // 根据提供商选择不同的API端点
                let apiEndpoint = '';
                let headers: Record<string, string> = {
                    'Content-Type': 'application/json'
                };
                let body: any = {};

                // 自定义API BASE URL
                // 普通API: https://api.deepseek.com
                // Beta API: https://api.deepseek.com/beta
                // 可根据请求参数动态选择
                const getApiBaseUrl = (args: any): string => {
                    // 如果参数中指定了base_url，则使用该值
                    if (args && args.base_url) {
                        return args.base_url;
                    }

                    // 如果需要Beta功能（超过4096输出token等），则使用Beta API
                    if (args && args.request_options) {
                        try {
                            const options = typeof args.request_options === 'string'
                                ? JSON.parse(args.request_options)
                                : args.request_options;

                            if (options.max_tokens && options.max_tokens > 4096) {
                                return 'https://api.deepseek.com/beta';
                            }
                        } catch (e) {
                            console.error('解析请求选项失败', e);
                        }
                    }

                    // 默认使用普通API
                    return 'https://api.deepseek.com';
                };

                // 根据不同的提供商配置请求
                switch (cmdProvider) {
                    case 'deepseek':
                        apiEndpoint = `${getApiBaseUrl(args)}/chat/completions`;
                        headers['Authorization'] = `Bearer ${apiKey}`;
                        body = {
                            model: options.model,
                            messages: options.messages || [],
                            temperature: options.temperature || 0.7,
                            max_tokens: options.max_tokens || 1000,
                            stream: options.stream || false
                        };
                        break;

                    case 'siliconflow':
                        apiEndpoint = 'https://api.siliconflow.cn/v1/chat/completions';
                        headers['Authorization'] = `Bearer ${apiKey}`;
                        body = {
                            model: options.model,
                            messages: options.messages || [],
                            temperature: options.temperature || 0.7,
                            max_tokens: options.max_tokens || 1000,
                            stream: options.stream || false
                        };
                        break;

                    default:
                        // 默认使用DeepSeek API
                        apiEndpoint = 'https://api.deepseek.com/chat/completions';
                        headers['Authorization'] = `Bearer ${apiKey}`;
                        body = {
                            model: options.model,
                            messages: options.messages || [],
                            temperature: options.temperature || 0.7,
                            max_tokens: options.max_tokens || 1000
                        };
                }

                // 记录请求详情
                console.log(`调用API: ${apiEndpoint} (${cmdProvider})`);
                console.log(`请求头:`, Object.keys(headers).join(', '));
                console.log(`请求体:`, {
                    模型: body.model || '使用OpenAI格式',
                    消息数量: options.messages.length,
                    参数: {
                        temperature: options.temperature || 0.7,
                        maxTokens: options.max_tokens || 1000
                    }
                });

                try {
                    // 发起API请求
                    const response = await fetch(apiEndpoint, {
                        method: 'POST',
                        headers: headers,
                        body: JSON.stringify(body)
                    });

                    // 获取完整的响应内容
                    const responseText = await response.text();
                    console.log(`API响应状态: ${response.status} ${response.statusText}`);
                    console.log(`API响应内容: ${responseText.substring(0, 200)}${responseText.length > 200 ? '...' : ''}`);

                    // 尝试解析为JSON
                    let responseData;
                    try {
                        // 移除'data:'前缀后再解析JSON
                        const cleanResponseText = responseText.replace(/^data:\s*/, '');
                        responseData = cleanResponseText ? JSON.parse(cleanResponseText) : null;
                    } catch (jsonError) {
                        console.error('解析JSON响应失败:', jsonError);
                        responseData = { raw: responseText };
                    }

                    // 错误处理
                    if (!response.ok) {
                        // 提取错误信息
                        const errorInfo = responseData?.error?.message ||
                            responseData?.error?.code ||
                            responseData?.detail ||
                            responseData?.error?.type ||
                            `HTTP错误 ${response.status} ${response.statusText}`;

                        const detailedError = {
                            status: response.status,
                            statusText: response.statusText,
                            errorInfo: errorInfo,
                            model: options.model,
                            endpoint: apiEndpoint
                        };

                        console.error(`API请求失败 [${response.status}]:`, JSON.stringify(detailedError, null, 2));

                        return {
                            success: false,
                            error: `API请求失败: ${response.status} - ${errorInfo}`,
                            details: detailedError
                        };
                    }

                    // 成功响应，提取内容
                    let content = '';

                    // 根据模型类型处理响应
                    if (modelLower.includes('deepseek') ||
                        modelLower.includes('glm') ||
                        modelLower.includes('zhipu') ||
                        modelLower.includes('yi') ||
                        modelLower.includes('qwen') ||
                        modelLower.includes('moonshot') ||
                        modelLower.includes('baichuan')) {
                        // DeepSeek和硅基流动API使用OpenAI兼容格式
                        content = responseData?.choices?.[0]?.message?.content || '';
                    } else {
                        // 通用处理
                        content = responseData?.choices?.[0]?.message?.content ||
                            responseData?.content?.[0]?.text ||
                            '收到响应，但无法解析内容';
                    }

                    return {
                        success: true,
                        content
                    };
                } catch (fetchError) {
                    console.error('网络请求失败:', fetchError);
                    return {
                        success: false,
                        error: `网络请求失败: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`
                    };
                }
            } catch (error) {
                console.error('HTTP请求失败:', error);
                return {
                    success: false,
                    error: `HTTP请求失败: ${error instanceof Error ? error.message : String(error)}`
                };
            }
        }

        // 对于不支持的命令，返回明确的错误信息
        console.error(`尝试调用未实现的命令: ${cmd}`);
        return {
            success: false,
            error: `未实现的命令: ${cmd}`
        };
    };
};

// 立即调用初始化函数
initApi().catch(err => console.error('API初始化失败:', err));

/**
 * 获取invoke函数
 * 添加更完善的错误处理
 */
export const getInvoke = (): InvokeFunction => {
    // 如果是Electron环境，使用window.electron.invoke
    if (typeof window !== 'undefined' && window.electron?.invoke) {
        console.log('使用Electron API');
        return window.electron.invoke;
    }

    // 如果已初始化API，返回当前的invoke函数
    if (apiInitialized && invoke) {
        return invoke;
    }

    // 返回一个占位函数，它会报告错误
    return async (channel: string, data: any) => {
        console.error(`调用失败: API尚未初始化，无法调用${channel}`);
        return {
            success: false,
            error: 'API尚未初始化',
            content: null
        };
    };
};

/**
 * 使用流式回调调用API
 * 改进流式响应处理，添加超时检测和完成处理
 */
export async function invokeWithStreamCallback(
    channel: string,
    data: any,
    callback: (chunk: string) => void
): Promise<any> {
    try {
        // 确保API已初始化
        await ensureApiInitialized();
        const invokeFunc = getInvoke();

        // 如果是Electron环境且支持流式响应
        if (typeof window !== 'undefined' && window.electron?.onStreamData) {
            // 创建一个可控制流程的Promise
            return new Promise((resolve, reject) => {
                let isCompleted = false;
                let accumulatedResponse = '';
                let timeoutId: NodeJS.Timeout;

                // 设置一个超时检查，确保流式响应正常结束
                const checkCompletion = () => {
                    timeoutId = setTimeout(() => {
                        if (!isCompleted) {
                            // 如果在一定时间内没有收到新的数据，认为流已经结束
                            console.log('流式响应超时，自动完成');
                            isCompleted = true;
                            resolve({
                                success: true,
                                content: accumulatedResponse
                            });
                        }
                    }, 5000); // 5秒无响应则认为已完成
                };

                // 启动初始检查
                checkCompletion();

                // 处理每个数据块
                if (window.electron) {
                    window.electron.onStreamData((event: any, chunk: string) => {
                        // 重置超时计时器
                        clearTimeout(timeoutId);

                        // 检查是否是完成标记
                        if (chunk === '[DONE]' || chunk.includes('[DONE]')) {
                            isCompleted = true;
                            resolve({
                                success: true,
                                content: accumulatedResponse
                            });
                            return;
                        }

                        // 处理普通数据块
                        try {
                            accumulatedResponse += chunk;
                            callback(chunk);

                            // 设置新的检查
                            checkCompletion();
                        } catch (error) {
                            console.error('处理流式数据块时出错:', error);
                        }
                    });

                    // 处理错误
                    window.electron.onStreamError((event: any, error: string) => {
                        clearTimeout(timeoutId);
                        console.error('流式响应错误:', error);
                        reject(new Error(error));
                    });
                } else {
                    // 如果electron不可用，直接拒绝Promise
                    reject(new Error('不支持流式响应: electron对象不可用'));
                    return;
                }

                // 初始调用
                invokeFunc(channel, { ...data, stream: true })
                    .catch((error: any) => {
                        clearTimeout(timeoutId);
                        console.error('调用API时出错:', error);
                        reject(error);
                    });
            });
        } else {
            // 如果不支持流式响应，使用普通调用
            console.log('环境不支持流式响应，使用普通API调用');
            const result = await invokeFunc(channel, data);
            if (result.success && result.content) {
                callback(result.content);
            }
            return result;
        }
    } catch (error) {
        console.error('流式响应处理失败:', error);
        throw error;
    }
} 